const express = require('express');
const router = express.Router();
const { ApiKey, User } = require('../models');
const { authenticateToken, isAdmin } = require('../middleware/auth');

/**
 * 创建密钥掩码显示
 * @param {string} apiKey - 完整的API密钥
 * @returns {string} - 掩码后的密钥
 */
function maskApiKey(apiKey) {
  if (!apiKey || apiKey.length < 8) {
    return '****';
  }
  
  const start = apiKey.substring(0, 4);
  const end = apiKey.substring(apiKey.length - 4);
  const middle = '*'.repeat(Math.max(8, apiKey.length - 8));
  
  return `${start}${middle}${end}`;
}

/**
 * 验证API密钥格式
 * @param {string} provider - API提供商
 * @param {string} apiKey - API密钥
 * @returns {boolean} - 是否有效
 */
function validateApiKeyFormat(provider, apiKey) {
  if (!apiKey || typeof apiKey !== 'string') {
    return false;
  }

  // 根据不同提供商验证密钥格式
  switch (provider.toLowerCase()) {
    case 'openai':
      // OpenAI密钥格式: sk-xxxxxx
      return /^sk-[a-zA-Z0-9]{32,}$/.test(apiKey);
    case 'claude':
      // Anthropic Claude密钥格式: sk-ant-api03-xxxxxx
      return /^sk-ant-[a-zA-Z0-9]{1,}-[a-zA-Z0-9]{32,}$/.test(apiKey);
    case 'deepseek':
      // DeepSeek密钥格式: sk-xxxxxx
      return /^sk-[a-zA-Z0-9]{32,}$/.test(apiKey);
    case 'volcengine':
      // 火山引擎密钥格式: 通常为UUID格式或长字符串
      return apiKey.length >= 20;
    case 'gemini':
      // Google Gemini密钥格式: 通常为长字母数字字符串
      return apiKey.length >= 20;
    default:
      // 其他提供商，宽松验证
      return apiKey.length >= 10;
  }
}

// 获取所有API密钥列表（管理员）
router.get('/', authenticateToken, isAdmin, async (req, res) => {
  try {
    const includeKeys = req.query.include_keys === 'true';
    
    let attributes = ['id', 'name', 'provider', 'is_active', 'usage_count', 'last_used_at', 'daily_limit', 'monthly_limit', 'notes', 'created_at'];
    
    if (includeKeys) {
      attributes.push('api_key', 'api_config');
    }

    const apiKeys = await ApiKey.findAll({
      include: [{
        model: User,
        attributes: ['id', 'username']
      }],
      attributes: attributes,
      order: [['created_at', 'DESC']]
    });

    if (includeKeys) {
      const apiKeysWithMasked = apiKeys.map(apiKey => {
        const keyData = apiKey.toJSON();
        try {
          // 解密API密钥
          const decryptedKey = apiKey.getDecryptedKey();
          keyData.api_key = decryptedKey ? maskApiKey(decryptedKey) : null;
          keyData.has_key = !!decryptedKey;
          // 安全日志：不记录敏感信息
        } catch (error) {
          console.error(`密钥处理失败: ${apiKey.provider}`);
          keyData.api_key = null;
        }
        return keyData;
      });
      
      res.json({
        success: true,
        data: apiKeysWithMasked
      });
    } else {
      res.json({
        success: true,
        data: apiKeys
      });
    }
  } catch (error) {
    console.error('获取API密钥列表失败:', error);
    res.status(500).json({
      error: '获取API密钥列表失败'
    });
  }
});

// 根据提供商获取可用的API密钥（内部使用）
router.get('/provider/:provider', authenticateToken, async (req, res) => {
  try {
    const { provider } = req.params;

    // 验证提供商类型
    if (!provider || provider.trim() === '') {
      return res.status(400).json({
        error: '无效的API提供商'
      });
    }

    const apiKey = await ApiKey.getActiveKeyByProvider(provider);

    if (!apiKey) {
      return res.status(404).json({
        error: `未找到可用的${provider} API密钥`
      });
    }

    res.json({
      success: true,
      data: {
        api_key: apiKey,
        provider: provider
      }
    });
  } catch (error) {
    console.error('获取API密钥失败:', error);
    res.status(500).json({
      error: '获取API密钥失败'
    });
  }
});

// 获取所有提供商的可用密钥概览
router.get('/overview', authenticateToken, isAdmin, async (req, res) => {
  try {
    const overview = await ApiKey.getAllActiveKeys();

    res.json({
      success: true,
      data: overview
    });
  } catch (error) {
    console.error('获取API密钥概览失败:', error);
    res.status(500).json({
      error: '获取API密钥概览失败'
    });
  }
});

// 获取单个API密钥详情（管理员）
router.get('/:id', authenticateToken, isAdmin, async (req, res) => {
  try {
    const { id } = req.params;

    const apiKey = await ApiKey.findByPk(id, {
      include: [{
        model: User,
        attributes: ['id', 'username']
      }],
      attributes: ['id', 'name', 'provider', 'is_active', 'usage_count', 'last_used_at', 'daily_limit', 'monthly_limit', 'notes', 'created_at', 'updated_at']
    });

    if (!apiKey) {
      return res.status(404).json({
        success: false,
        error: 'API密钥不存在'
      });
    }

    res.json({
      success: true,
      data: apiKey
    });
  } catch (error) {
    console.error('获取API密钥详情失败:', error);
    res.status(500).json({
      success: false,
      error: '获取API密钥详情失败'
    });
  }
});

// 创建新的API密钥（管理员）
router.post('/', authenticateToken, isAdmin, async (req, res) => {
  try {
    const { name, provider, api_key, daily_limit, monthly_limit, notes, api_config } = req.body;

    // 验证必填字段
    if (!name || !provider || !api_key) {
      return res.status(400).json({
        success: false,
        error: '名称、提供商和API密钥为必填字段'
      });
    }

    // 验证提供商类型
    if (!provider || provider.trim() === '') {
      return res.status(400).json({
        success: false,
        error: '无效的API提供商类型'
      });
    }

    // 验证API密钥格式
    if (!validateApiKeyFormat(provider, api_key)) {
      return res.status(400).json({
        success: false,
        error: `无效的${provider} API密钥格式`,
        message: '请检查API密钥格式是否正确'
      });
    }

    // 检查是否已存在相同名称的密钥
    const existingKey = await ApiKey.findOne({
      where: { name: name }
    });

    if (existingKey) {
      return res.status(409).json({
        success: false,
        error: '已存在相同名称的API密钥'
      });
    }

    const newApiKey = await ApiKey.create({
      name,
      provider,
      api_key,
      daily_limit: daily_limit || null,
      monthly_limit: monthly_limit || null,
      notes: notes || null,
      api_config: api_config || null,
      created_by: req.user.id
    });

    // 返回创建的密钥信息（不包含实际密钥）
    const result = await ApiKey.findByPk(newApiKey.id, {
      include: [{
        model: User,
        attributes: ['id', 'username']
      }],
      attributes: ['id', 'name', 'provider', 'is_active', 'usage_count', 'daily_limit', 'monthly_limit', 'notes', 'created_at']
    });

    res.status(201).json({
      success: true,
      message: 'API密钥创建成功',
      data: result
    });
  } catch (error) {
    console.error('创建API密钥失败:', error);
    res.status(500).json({
      success: false,
      error: '创建API密钥失败',
      message: error.message,
      details: process.env.NODE_ENV === 'development' ? error.stack : undefined
    });
  }
});

// 更新API密钥（管理员）
router.put('/:id', authenticateToken, isAdmin, async (req, res) => {
  try {
    const { id } = req.params;
    const { name, provider, api_key, is_active, daily_limit, monthly_limit, notes, api_config } = req.body;

    const apiKeyRecord = await ApiKey.findByPk(id);
    if (!apiKeyRecord) {
      return res.status(404).json({
        success: false,
        error: 'API密钥不存在'
      });
    }

    // 验证提供商类型
    if (provider && provider.trim() === '') {
      return res.status(400).json({
        success: false,
        error: '无效的API提供商类型'
      });
    }

    // 验证API密钥格式
    if (api_key) {
      const providerToCheck = provider || apiKeyRecord.provider;
      if (!validateApiKeyFormat(providerToCheck, api_key)) {
        return res.status(400).json({
          success: false,
          error: `无效的${providerToCheck} API密钥格式`,
          message: '请检查API密钥格式是否正确'
        });
      }
    }

    // 检查是否已存在相同名称的密钥（排除当前记录）
    if (name && name !== apiKeyRecord.name) {
      const existingKey = await ApiKey.findOne({
        where: { name: name }
      });

      if (existingKey) {
        return res.status(409).json({
          success: false,
          error: '已存在相同名称的API密钥'
        });
      }
    }

    // 更新记录
    const updateData = {};
    if (name) updateData.name = name;
    if (provider) updateData.provider = provider;
    if (api_key) updateData.api_key = api_key;
    if (is_active !== undefined) updateData.is_active = is_active;
    if (daily_limit !== undefined) updateData.daily_limit = daily_limit || null;
    if (monthly_limit !== undefined) updateData.monthly_limit = monthly_limit || null;
    if (notes !== undefined) updateData.notes = notes || null;
    if (api_config !== undefined) updateData.api_config = api_config || null;

    await apiKeyRecord.update(updateData);

    // 返回更新后的密钥信息（不包含实际密钥）
    const result = await ApiKey.findByPk(id, {
      include: [{
        model: User,
        attributes: ['id', 'username']
      }],
      attributes: ['id', 'name', 'provider', 'is_active', 'usage_count', 'daily_limit', 'monthly_limit', 'notes', 'created_at', 'updated_at']
    });

    res.json({
      success: true,
      message: 'API密钥更新成功',
      data: result
    });
  } catch (error) {
    console.error('更新API密钥失败:', error);
    res.status(500).json({
      success: false,
      error: '更新API密钥失败',
      message: error.message,
      details: process.env.NODE_ENV === 'development' ? error.stack : undefined
    });
  }
});

// 删除API密钥（管理员）
router.delete('/:id', authenticateToken, isAdmin, async (req, res) => {
  try {
    const { id } = req.params;

    const apiKeyRecord = await ApiKey.findByPk(id);
    if (!apiKeyRecord) {
      return res.status(404).json({
        error: 'API密钥不存在'
      });
    }

    await apiKeyRecord.destroy();

    res.json({
      success: true,
      message: 'API密钥删除成功'
    });
  } catch (error) {
    console.error('删除API密钥失败:', error);
    res.status(500).json({
      error: '删除API密钥失败'
    });
  }
});

// 测试API密钥有效性（管理员）
router.post('/:id/test', authenticateToken, isAdmin, async (req, res) => {
  try {
    const { id } = req.params;

    const apiKeyRecord = await ApiKey.findByPk(id);
    if (!apiKeyRecord) {
      return res.status(404).json({
        error: 'API密钥不存在'
      });
    }

    if (!apiKeyRecord.is_active) {
      return res.status(400).json({
        error: 'API密钥已禁用'
      });
    }

    const decryptedKey = apiKeyRecord.getDecryptedKey();
    if (!decryptedKey) {
      return res.status(500).json({
        error: 'API密钥解密失败'
      });
    }

    // 这里可以添加实际的API测试逻辑
    // 例如调用对应提供商的API进行验证

    res.json({
      success: true,
      message: 'API密钥测试成功',
      data: {
        provider: apiKeyRecord.provider,
        key_length: decryptedKey.length,
        is_valid: true // 实际应该通过API调用验证
      }
    });
  } catch (error) {
    console.error('测试API密钥失败:', error);
    res.status(500).json({
      error: '测试API密钥失败'
    });
  }
});

module.exports = router;
